home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / front.lha / front / m2c / Rules.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  21KB  |  754 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Lists
  4. #include "Lists.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_TokenTab
  8. #include "TokenTab.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Memory
  12. #include "Memory.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Idents
  16. #include "Idents.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Errors
  20. #include "Errors.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Strings
  24. #include "Strings.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Positions
  28. #include "Positions.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Rules
  32. #include "Rules.h"
  33. #endif
  34.  
  35. Rules_Expression Rules_NoExpression;
  36.  
  37. #define eNoOperator    41
  38. #define eTermLeft    42
  39. #define eTokenNotDecl    32
  40. typedef struct S_1 *Expression;
  41. typedef struct S_1 {
  42.     Rules_Operation Type;
  43.     union {
  44.         struct {
  45.             Rules_Expression Son;
  46.         } V_1;
  47.         struct {
  48.             Rules_Expression LeSon, RiSon;
  49.         } V_2;
  50.         struct {
  51.             Lists_tList Act;
  52.         } V_3;
  53.         struct {
  54.             TokenTab_Vocabulary Token;
  55.         } V_4;
  56.     } U_1;
  57.     TokenTab_PosType Position, SecondPos;
  58.     ADDRESS Special;
  59.     BOOLEAN HasPrio;
  60.     TokenTab_PosType PRIOPos;
  61.     Idents_tIdent PrioSym;
  62.     TokenTab_PosType PrioSymPos;
  63. } Node;
  64. typedef struct S_2 *MRules;
  65. typedef struct S_2 {
  66.     TokenTab_NonTerminal Left;
  67.     TokenTab_PosType LeftPos;
  68.     TokenTab_PosType ColonPos;
  69.     Rules_Expression Right;
  70.     TokenTab_PosType PointPos;
  71.     Lists_tList Comment;
  72.     TokenTab_PosType CommPos;
  73.     BOOLEAN HasPrio;
  74.     union {
  75.         struct {
  76.             TokenTab_PosType PRIOPos;
  77.             SHORTCARD Priority;
  78.             TokenTab_Terminal PrioSym;
  79.             TokenTab_PosType PrioSymPos;
  80.         } V_1;
  81.     } U_1;
  82.     Rules_MRules Next;
  83. } Rule;
  84. static struct S_3 {
  85.     TokenTab_PosType RULESPos;
  86.     Lists_tList Comment;
  87.     TokenTab_PosType CommPos;
  88. } RulesVars;
  89. static Rules_MRules StartMRule, RMRule, WMRule;
  90. static BOOLEAN OpenForReading;
  91. static Rules_Expression MakeArtificialNode ARGS((TokenTab_PosType Pos, TokenTab_PosType SecPos, Rules_Expression LSon, Rules_Expression RSon));
  92. static void ERROR ARGS((CHAR a[], LONGCARD ));
  93.  
  94.  
  95. Rules_Expression Rules_MakeLeafNode
  96. # ifdef __STDC__
  97. (Idents_tIdent sym, TokenTab_PosType Pos)
  98. # else
  99. (sym, Pos)
  100. Idents_tIdent sym;
  101. TokenTab_PosType Pos;
  102. # endif
  103. {
  104.   Rules_Expression HNode;
  105.   TokenTab_TokenError Error;
  106.   TokenTab_Vocabulary voc;
  107.  
  108.   HNode = (Rules_Expression)Memory_Alloc((LONGINT)sizeof(Node));
  109.   if (HNode == NIL) {
  110.     ERROR((STRING)"MakeLeafNode: Heap overflow", 27L);
  111.   }
  112.   ((Expression)HNode)->Position = Pos;
  113.   ((Expression)HNode)->Special = (ADDRESS)NIL;
  114.   voc = TokenTab_MakeVoc(sym, Pos);
  115.   if (TokenTab_GetTokenType(voc) == TokenTab_Term) {
  116.     ((Expression)HNode)->Type = Rules_TermLeaf;
  117.     ((Expression)HNode)->U_1.V_4.Token = voc;
  118.   } else {
  119.     ((Expression)HNode)->Type = Rules_NonTermLeaf;
  120.     ((Expression)HNode)->U_1.V_4.Token = voc;
  121.   }
  122.   return HNode;
  123. }
  124.  
  125. Rules_Expression Rules_MakeActionNode
  126. # ifdef __STDC__
  127. (Lists_tList Act, TokenTab_PosType Pos)
  128. # else
  129. (Act, Pos)
  130. Lists_tList Act;
  131. TokenTab_PosType Pos;
  132. # endif
  133. {
  134.   Rules_Expression HNode;
  135.   Strings_tString s;
  136.  
  137.   HNode = (Rules_Expression)Memory_Alloc((LONGINT)sizeof(Node));
  138.   if (HNode == NIL) {
  139.     Strings_ArrayToString((STRING)"MakeActionNode : Heap overflow", 30L, &s);
  140.     Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Pos, (LONGCARD)Errors_eString, ADR(s));
  141.   }
  142.   ((Expression)HNode)->Special = (ADDRESS)NIL;
  143.   ((Expression)HNode)->Type = Rules_Action;
  144.   ((Expression)HNode)->U_1.V_3.Act = Act;
  145.   ((Expression)HNode)->Position = Pos;
  146.   return HNode;
  147. }
  148.  
  149. Rules_Expression Rules_MakeUnaryNode
  150. # ifdef __STDC__
  151. (Rules_UnaryOperation Type, TokenTab_PosType Pos, Rules_Expression Son)
  152. # else
  153. (Type, Pos, Son)
  154. Rules_UnaryOperation Type;
  155. TokenTab_PosType Pos;
  156. Rules_Expression Son;
  157. # endif
  158. {
  159.   Rules_Expression HNode;
  160.   Strings_tString s;
  161.  
  162.   HNode = (Rules_Expression)Memory_Alloc((LONGINT)sizeof(Node));
  163.   if (HNode == NIL) {
  164.     Strings_ArrayToString((STRING)" MakeUnaryNode : Heap overflow", 30L, &s);
  165.     Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Pos, (LONGCARD)Errors_eString, ADR(s));
  166.   }
  167.   ((Expression)HNode)->Special = (ADDRESS)NIL;
  168.   ((Expression)HNode)->Type = Type;
  169.   ((Expression)HNode)->Position = Pos;
  170.   ((Expression)HNode)->U_1.V_1.Son = Son;
  171.   return HNode;
  172. }
  173.  
  174. Rules_Expression Rules_MakeBracketNode
  175. # ifdef __STDC__
  176. (Rules_BracketOperation Type, TokenTab_PosType Pos, TokenTab_PosType SecPos, Rules_Expression Son)
  177. # else
  178. (Type, Pos, SecPos, Son)
  179. Rules_BracketOperation Type;
  180. TokenTab_PosType Pos, SecPos;
  181. Rules_Expression Son;
  182. # endif
  183. {
  184.   Rules_Expression HNode;
  185.   Strings_tString s;
  186.  
  187.   HNode = (Rules_Expression)Memory_Alloc((LONGINT)sizeof(Node));
  188.   if (HNode == NIL) {
  189.     Strings_ArrayToString((STRING)"MakeBracketNode : Heap overflow", 31L, &s);
  190.     Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Pos, (LONGCARD)Errors_eString, ADR(s));
  191.   }
  192.   ((Expression)HNode)->Special = (ADDRESS)NIL;
  193.   ((Expression)HNode)->Type = Type;
  194.   ((Expression)HNode)->Position = Pos;
  195.   ((Expression)HNode)->SecondPos = SecPos;
  196.   ((Expression)HNode)->U_1.V_1.Son = Son;
  197.   return HNode;
  198. }
  199.  
  200. Rules_Expression Rules_MakeBinaryNode
  201. # ifdef __STDC__
  202. (Rules_BinaryOperation Type, TokenTab_PosType Pos, Rules_Expression LSon, Rules_Expression RSon)
  203. # else
  204. (Type, Pos, LSon, RSon)
  205. Rules_BinaryOperation Type;
  206. TokenTab_PosType Pos;
  207. Rules_Expression LSon, RSon;
  208. # endif
  209. {
  210.   Rules_Expression HNode;
  211.   Strings_tString s;
  212.  
  213.   HNode = (Rules_Expression)Memory_Alloc((LONGINT)sizeof(Node));
  214.   if (HNode == NIL) {
  215.     Strings_ArrayToString((STRING)"MakeBinaryNode : Heap overflow", 30L, &s);
  216.     Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Pos, (LONGCARD)Errors_eString, ADR(s));
  217.   }
  218.   ((Expression)HNode)->Special = (ADDRESS)NIL;
  219.   ((Expression)HNode)->Type = Type;
  220.   ((Expression)HNode)->Position = Pos;
  221.   ((Expression)HNode)->U_1.V_2.LeSon = LSon;
  222.   ((Expression)HNode)->U_1.V_2.RiSon = RSon;
  223.   if (Type == Rules_Alternative) {
  224.     ((Expression)HNode)->HasPrio = FALSE;
  225.   }
  226.   return HNode;
  227. }
  228.  
  229. Rules_Expression Rules_MakePrioAlternativeNode
  230. # ifdef __STDC__
  231. (TokenTab_PosType Pos, Rules_Expression LSon, Rules_Expression RSon, BOOLEAN HasPrio, TokenTab_PosType PRIOPos, Idents_tIdent PrioSym, TokenTab_PosType PrioSymPos)
  232. # else
  233. (Pos, LSon, RSon, HasPrio, PRIOPos, PrioSym, PrioSymPos)
  234. TokenTab_PosType Pos;
  235. Rules_Expression LSon, RSon;
  236. BOOLEAN HasPrio;
  237. TokenTab_PosType PRIOPos;
  238. Idents_tIdent PrioSym;
  239. TokenTab_PosType PrioSymPos;
  240. # endif
  241. {
  242.   Rules_Expression HNode;
  243.   Strings_tString s;
  244.  
  245.   HNode = (Rules_Expression)Memory_Alloc((LONGINT)sizeof(Node));
  246.   if (HNode == NIL) {
  247.     Strings_ArrayToString((STRING)"MakePrioAlternativeNode : Heap overflow", 39L, &s);
  248.     Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Pos, (LONGCARD)Errors_eString, ADR(s));
  249.   }
  250.   ((Expression)HNode)->HasPrio = HasPrio;
  251.   ((Expression)HNode)->PRIOPos = PRIOPos;
  252.   ((Expression)HNode)->PrioSym = PrioSym;
  253.   ((Expression)HNode)->PrioSymPos = PrioSymPos;
  254.   ((Expression)HNode)->Special = (ADDRESS)NIL;
  255.   ((Expression)HNode)->Type = Rules_Alternative;
  256.   ((Expression)HNode)->Position = Pos;
  257.   ((Expression)HNode)->U_1.V_2.LeSon = LSon;
  258.   ((Expression)HNode)->U_1.V_2.RiSon = RSon;
  259.   return HNode;
  260. }
  261.  
  262. void Rules_AppendArtificialNode
  263. # ifdef __STDC__
  264. (TokenTab_PosType Pos, TokenTab_PosType Pos2, Rules_Expression *Expr, Rules_Expression New)
  265. # else
  266. (Pos, Pos2, Expr, New)
  267. TokenTab_PosType Pos, Pos2;
  268. Rules_Expression *Expr;
  269. Rules_Expression New;
  270. # endif
  271. {
  272.   Rules_Expression last, expr;
  273.  
  274.   if (*Expr == Rules_NoExpression || Rules_GetNodeOperation(*Expr) != Rules_ArtAlternative) {
  275.     *Expr = MakeArtificialNode(Pos, Pos2, *Expr, New);
  276.   } else {
  277.     expr = *Expr;
  278.     for (;;) {
  279.       last = ((Expression)expr)->U_1.V_2.RiSon;
  280.       if (Rules_GetNodeOperation(last) != Rules_ArtAlternative) {
  281.         goto EXIT_1;
  282.       }
  283.       expr = last;
  284.     } EXIT_1:;
  285.     ((Expression)expr)->U_1.V_2.RiSon = MakeArtificialNode(((Expression)last)->Position, Pos2, last, New);
  286.   }
  287. }
  288.  
  289. static Rules_Expression MakeArtificialNode
  290. # ifdef __STDC__
  291. (TokenTab_PosType Pos, TokenTab_PosType SecPos, Rules_Expression LSon, Rules_Expression RSon)
  292. # else
  293. (Pos, SecPos, LSon, RSon)
  294. TokenTab_PosType Pos;
  295. TokenTab_PosType SecPos;
  296. Rules_Expression LSon, RSon;
  297. # endif
  298. {
  299.   Rules_Expression HNode;
  300.   Strings_tString s;
  301.  
  302.   HNode = (Rules_Expression)Memory_Alloc((LONGINT)sizeof(Node));
  303.   if (HNode == NIL) {
  304.     Strings_ArrayToString((STRING)"MakeArtificialNode : Heap overflow", 34L, &s);
  305.     Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Pos, (LONGCARD)Errors_eString, ADR(s));
  306.   }
  307.   ((Expression)HNode)->Special = (ADDRESS)NIL;
  308.   ((Expression)HNode)->Type = Rules_ArtAlternative;
  309.   ((Expression)HNode)->Position = Pos;
  310.   ((Expression)HNode)->SecondPos = SecPos;
  311.   ((Expression)HNode)->U_1.V_2.LeSon = LSon;
  312.   ((Expression)HNode)->U_1.V_2.RiSon = RSon;
  313.   return HNode;
  314. }
  315.  
  316. void Rules_PutNodeSpecial
  317. # ifdef __STDC__
  318. (Rules_Expression Expr, ADDRESS Spec)
  319. # else
  320. (Expr, Spec)
  321. Rules_Expression Expr;
  322. ADDRESS Spec;
  323. # endif
  324. {
  325.   if (Expr != NIL) {
  326.     ((Expression)Expr)->Special = Spec;
  327.   } else {
  328.     ERROR((STRING)"PutNodeSpecial : You tried to access an empty node", 50L);
  329.   }
  330. }
  331.  
  332. void Rules_MakeRule
  333. # ifdef __STDC__
  334. (Idents_tIdent Left, TokenTab_PosType LeftPos, TokenTab_PosType ColonPos, Rules_Expression Right, Lists_tList Comment, TokenTab_PosType CommPos, TokenTab_PosType PointPos, BOOLEAN HasPrio, TokenTab_PosType PRIOPos, Idents_tIdent PrioSym, TokenTab_PosType PrioSymPos)
  335. # else
  336. (Left, LeftPos, ColonPos, Right, Comment, CommPos, PointPos, HasPrio, PRIOPos, PrioSym, PrioSymPos)
  337. Idents_tIdent Left;
  338. TokenTab_PosType LeftPos;
  339. TokenTab_PosType ColonPos;
  340. Rules_Expression Right;
  341. Lists_tList Comment;
  342. TokenTab_PosType CommPos;
  343. TokenTab_PosType PointPos;
  344. BOOLEAN HasPrio;
  345. TokenTab_PosType PRIOPos;
  346. Idents_tIdent PrioSym;
  347. TokenTab_PosType PrioSymPos;
  348. # endif
  349. {
  350.   Rules_MRules HRule;
  351.   TokenTab_TokenError Error;
  352.   TokenTab_Vocabulary Leftvoc;
  353.   TokenTab_Vocabulary voc;
  354.   Strings_tString s;
  355.  
  356.   OpenForReading = FALSE;
  357.   Leftvoc = TokenTab_MakeVoc(Left, LeftPos);
  358.   if (TokenTab_GetTokenType(Leftvoc) == TokenTab_Term) {
  359.     Errors_ErrorMessageI((LONGCARD)eTermLeft, (LONGCARD)Errors_eError, LeftPos, (LONGCARD)Errors_eIdent, ADR(Left));
  360.   } else {
  361.     TokenTab_SetNontermPos(Left, LeftPos);
  362.     HRule = (Rules_MRules)Memory_Alloc((LONGINT)sizeof(Rule));
  363.     if (HRule == NIL) {
  364.       Strings_ArrayToString((STRING)"MakeRule : Heap overflow", 24L, &s);
  365.       Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, LeftPos, (LONGCARD)Errors_eString, ADR(s));
  366.     }
  367.     ((MRules)HRule)->Left = Leftvoc;
  368.     ((MRules)HRule)->LeftPos = LeftPos;
  369.     ((MRules)HRule)->ColonPos = ColonPos;
  370.     ((MRules)HRule)->PointPos = PointPos;
  371.     ((MRules)HRule)->Right = Right;
  372.     ((MRules)HRule)->Comment = Comment;
  373.     ((MRules)HRule)->CommPos = CommPos;
  374.     ((MRules)HRule)->HasPrio = HasPrio;
  375.     ((MRules)HRule)->U_1.V_1.Priority = 0;
  376.     if (HasPrio) {
  377.       ((MRules)HRule)->U_1.V_1.PRIOPos = PRIOPos;
  378.       ((MRules)HRule)->U_1.V_1.PrioSymPos = PrioSymPos;
  379.       voc = TokenTab_SymbolToToken(PrioSym, &Error);
  380.       if (Error != TokenTab_NoError) {
  381.         Errors_ErrorMessageI((LONGCARD)eTokenNotDecl, (LONGCARD)Errors_eError, PrioSymPos, (LONGCARD)Errors_eIdent, ADR(PrioSym));
  382.       } else {
  383.         ((MRules)HRule)->U_1.V_1.PrioSym = voc;
  384.         ((MRules)HRule)->U_1.V_1.Priority = TokenTab_GetPrio(voc);
  385.         if (((MRules)HRule)->U_1.V_1.Priority == 0) {
  386.           Errors_ErrorMessageI((LONGCARD)eNoOperator, (LONGCARD)Errors_eError, PrioSymPos, (LONGCARD)Errors_eIdent, ADR(PrioSym));
  387.         }
  388.       }
  389.     }
  390.     if (WMRule != NIL) {
  391.       ((MRules)WMRule)->Next = HRule;
  392.     } else {
  393.       StartMRule = HRule;
  394.     }
  395.     ((MRules)HRule)->Next = (Rules_MRules)NIL;
  396.     WMRule = HRule;
  397.   }
  398. }
  399.  
  400. void Rules_MakeRulesHeader
  401. # ifdef __STDC__
  402. (TokenTab_PosType RULESPos, Lists_tList Comment, TokenTab_PosType CommPos)
  403. # else
  404. (RULESPos, Comment, CommPos)
  405. TokenTab_PosType RULESPos;
  406. Lists_tList Comment;
  407. TokenTab_PosType CommPos;
  408. # endif
  409. {
  410.   RulesVars.RULESPos = RULESPos;
  411.   RulesVars.Comment = Comment;
  412.   RulesVars.CommPos = CommPos;
  413. }
  414.  
  415. void Rules_InitRulesReading
  416. # ifdef __STDC__
  417. ()
  418. # else
  419. ()
  420. # endif
  421. {
  422.   OpenForReading = TRUE;
  423.   RMRule = StartMRule;
  424. }
  425.  
  426. Rules_Operation Rules_GetNodeOperation
  427. # ifdef __STDC__
  428. (Rules_Expression Expr)
  429. # else
  430. (Expr)
  431. Rules_Expression Expr;
  432. # endif
  433. {
  434.   if (Expr == NIL) {
  435.     return Rules_NoOperation;
  436.   } else {
  437.     return ((Expression)Expr)->Type;
  438.   }
  439. }
  440.  
  441. void Rules_GetLeafNode
  442. # ifdef __STDC__
  443. (Rules_Expression Expr, TokenTab_Vocabulary *Voc, TokenTab_PosType *Pos)
  444. # else
  445. (Expr, Voc, Pos)
  446. Rules_Expression Expr;
  447. TokenTab_Vocabulary *Voc;
  448. TokenTab_PosType *Pos;
  449. # endif
  450. {
  451.   if (Rules_GetNodeOperation(Expr) != Rules_TermLeaf && Rules_GetNodeOperation(Expr) != Rules_NonTermLeaf) {
  452.     ERROR((STRING)"GetLeafNode : Wrong Node Type", 29L);
  453.   }
  454.   if (Expr != NIL) {
  455.     *Voc = ((Expression)Expr)->U_1.V_4.Token;
  456.     *Pos = ((Expression)Expr)->Position;
  457.   } else {
  458.     ERROR((STRING)"GetLeafNode : Node empty", 24L);
  459.   }
  460. }
  461.  
  462. void Rules_GetActionNode
  463. # ifdef __STDC__
  464. (Rules_Expression Expr, Lists_tList *Act, TokenTab_PosType *Pos)
  465. # else
  466. (Expr, Act, Pos)
  467. Rules_Expression Expr;
  468. Lists_tList *Act;
  469. TokenTab_PosType *Pos;
  470. # endif
  471. {
  472.   if (Rules_GetNodeOperation(Expr) != Rules_Action) {
  473.     ERROR((STRING)"GetActionNode : Wrong Node Type", 31L);
  474.   }
  475.   if (Expr != NIL) {
  476.     *Act = ((Expression)Expr)->U_1.V_3.Act;
  477.     *Pos = ((Expression)Expr)->Position;
  478.   } else {
  479.     ERROR((STRING)"GetActionNode : Node empty", 26L);
  480.   }
  481. }
  482.  
  483. void Rules_GetUnaryNode
  484. # ifdef __STDC__
  485. (Rules_Expression Expr, TokenTab_PosType *Pos, Rules_Expression *Son)
  486. # else
  487. (Expr, Pos, Son)
  488. Rules_Expression Expr;
  489. TokenTab_PosType *Pos;
  490. Rules_Expression *Son;
  491. # endif
  492. {
  493.   if (Rules_GetNodeOperation(Expr) != Rules_Star && Rules_GetNodeOperation(Expr) != Rules_Plus) {
  494.     ERROR((STRING)"GetUnaryNode : Wrong Node Type", 30L);
  495.   }
  496.   if (Expr != NIL) {
  497.     *Pos = ((Expression)Expr)->Position;
  498.     *Son = ((Expression)Expr)->U_1.V_1.Son;
  499.   } else {
  500.     ERROR((STRING)"GetUnaryNode : Node empty", 25L);
  501.   }
  502. }
  503.  
  504. void Rules_GetBracketNode
  505. # ifdef __STDC__
  506. (Rules_Expression Expr, TokenTab_PosType *Pos, TokenTab_PosType *SecPos, Rules_Expression *Son)
  507. # else
  508. (Expr, Pos, SecPos, Son)
  509. Rules_Expression Expr;
  510. TokenTab_PosType *Pos, *SecPos;
  511. Rules_Expression *Son;
  512. # endif
  513. {
  514.   if (Rules_GetNodeOperation(Expr) != Rules_Bracket && Rules_GetNodeOperation(Expr) != Rules_Optional) {
  515.     ERROR((STRING)"GetBracketNode : Wrong Node Type", 32L);
  516.   }
  517.   if (Expr != NIL) {
  518.     *Pos = ((Expression)Expr)->Position;
  519.     *SecPos = ((Expression)Expr)->SecondPos;
  520.     *Son = ((Expression)Expr)->U_1.V_1.Son;
  521.   } else {
  522.     ERROR((STRING)"GetBracketNode : Node empty", 27L);
  523.   }
  524. }
  525.  
  526. void Rules_GetBinaryNode
  527. # ifdef __STDC__
  528. (Rules_Expression Expr, TokenTab_PosType *Pos, Rules_Expression *LSon, Rules_Expression *RSon)
  529. # else
  530. (Expr, Pos, LSon, RSon)
  531. Rules_Expression Expr;
  532. TokenTab_PosType *Pos;
  533. Rules_Expression *LSon, *RSon;
  534. # endif
  535. {
  536.   if (Rules_GetNodeOperation(Expr) != Rules_Sequence && Rules_GetNodeOperation(Expr) != Rules_Separator && Rules_GetNodeOperation(Expr) != Rules_Alternative && Rules_GetNodeOperation(Expr) != Rules_ArtAlternative) {
  537.     ERROR((STRING)"GetBinaryNode : Wrong Node Type", 31L);
  538.   }
  539.   if (Expr != NIL) {
  540.     *Pos = ((Expression)Expr)->Position;
  541.     *LSon = ((Expression)Expr)->U_1.V_2.LeSon;
  542.     *RSon = ((Expression)Expr)->U_1.V_2.RiSon;
  543.   } else {
  544.     ERROR((STRING)"GetBinaryNode : Node empty", 26L);
  545.   }
  546. }
  547.  
  548. void Rules_GetPrioAlternativeNode
  549. # ifdef __STDC__
  550. (Rules_Expression Expr, TokenTab_PosType *Pos, Rules_Expression *LSon, Rules_Expression *RSon, BOOLEAN *HasPrio, TokenTab_PosType *PRIOPos, Idents_tIdent *PrioSym, TokenTab_PosType *PrioSymPos)
  551. # else
  552. (Expr, Pos, LSon, RSon, HasPrio, PRIOPos, PrioSym, PrioSymPos)
  553. Rules_Expression Expr;
  554. TokenTab_PosType *Pos;
  555. Rules_Expression *LSon;
  556. Rules_Expression *RSon;
  557. BOOLEAN *HasPrio;
  558. TokenTab_PosType *PRIOPos;
  559. Idents_tIdent *PrioSym;
  560. TokenTab_PosType *PrioSymPos;
  561. # endif
  562. {
  563.   if (Rules_GetNodeOperation(Expr) != Rules_Alternative) {
  564.     ERROR((STRING)"GetPrioAlternativeNode : Wrong Node Type", 40L);
  565.   }
  566.   if (Expr != NIL) {
  567.     *Pos = ((Expression)Expr)->Position;
  568.     *LSon = ((Expression)Expr)->U_1.V_2.LeSon;
  569.     *RSon = ((Expression)Expr)->U_1.V_2.RiSon;
  570.     *HasPrio = ((Expression)Expr)->HasPrio;
  571.     *PRIOPos = ((Expression)Expr)->PRIOPos;
  572.     *PrioSym = ((Expression)Expr)->PrioSym;
  573.     *PrioSymPos = ((Expression)Expr)->PrioSymPos;
  574.   } else {
  575.     ERROR((STRING)"GetPrioAlternativeNode : Node empty", 35L);
  576.   }
  577. }
  578.  
  579. void Rules_GetArtificialNode
  580. # ifdef __STDC__
  581. (Rules_Expression Expr, TokenTab_PosType *Pos, TokenTab_PosType *SecPos, Rules_Expression *LSon, Rules_Expression *RSon)
  582. # else
  583. (Expr, Pos, SecPos, LSon, RSon)
  584. Rules_Expression Expr;
  585. TokenTab_PosType *Pos;
  586. TokenTab_PosType *SecPos;
  587. Rules_Expression *LSon, *RSon;
  588. # endif
  589. {
  590.   if (Rules_GetNodeOperation(Expr) != Rules_ArtAlternative) {
  591.     ERROR((STRING)"GetArtificialNode : Wrong Node Type", 35L);
  592.   }
  593.   if (Expr != NIL) {
  594.     *Pos = ((Expression)Expr)->Position;
  595.     *SecPos = ((Expression)Expr)->SecondPos;
  596.     *LSon = ((Expression)Expr)->U_1.V_2.LeSon;
  597.     *RSon = ((Expression)Expr)->U_1.V_2.RiSon;
  598.   } else {
  599.     ERROR((STRING)"GetArtificialNode : Node empty", 30L);
  600.   }
  601. }
  602.  
  603. ADDRESS Rules_GetNodeSpecial
  604. # ifdef __STDC__
  605. (Rules_Expression Expr)
  606. # else
  607. (Expr)
  608. Rules_Expression Expr;
  609. # endif
  610. {
  611.   if (Expr != NIL) {
  612.     return ((Expression)Expr)->Special;
  613.   } else {
  614.     ERROR((STRING)"GetNodeSpecial : Node empty", 27L);
  615.     return (ADDRESS)NIL;
  616.   }
  617. }
  618.  
  619. BOOLEAN Rules_GetRule
  620. # ifdef __STDC__
  621. (TokenTab_NonTerminal *Left, TokenTab_PosType *LeftPos, TokenTab_PosType *ColonPos, Rules_Expression *Right, Lists_tList *Comment, TokenTab_PosType *CommPos, TokenTab_PosType *PointPos, BOOLEAN *HasPrio, TokenTab_PosType *PRIOPos, TokenTab_Terminal *PrioSym, TokenTab_PosType *PrioSymPos)
  622. # else
  623. (Left, LeftPos, ColonPos, Right, Comment, CommPos, PointPos, HasPrio, PRIOPos, PrioSym, PrioSymPos)
  624. TokenTab_NonTerminal *Left;
  625. TokenTab_PosType *LeftPos;
  626. TokenTab_PosType *ColonPos;
  627. Rules_Expression *Right;
  628. Lists_tList *Comment;
  629. TokenTab_PosType *CommPos;
  630. TokenTab_PosType *PointPos;
  631. BOOLEAN *HasPrio;
  632. TokenTab_PosType *PRIOPos;
  633. TokenTab_Terminal *PrioSym;
  634. TokenTab_PosType *PrioSymPos;
  635. # endif
  636. {
  637.   if (!OpenForReading) {
  638.     ERROR((STRING)"GetRule : You must not read here", 32L);
  639.   }
  640.   if (RMRule == NIL) {
  641.     return FALSE;
  642.   } else {
  643.     *Left = ((MRules)RMRule)->Left;
  644.     *LeftPos = ((MRules)RMRule)->LeftPos;
  645.     *ColonPos = ((MRules)RMRule)->ColonPos;
  646.     *PointPos = ((MRules)RMRule)->PointPos;
  647.     *Right = ((MRules)RMRule)->Right;
  648.     *Comment = ((MRules)RMRule)->Comment;
  649.     *CommPos = ((MRules)RMRule)->CommPos;
  650.     if (((MRules)RMRule)->HasPrio) {
  651.       *PRIOPos = ((MRules)RMRule)->U_1.V_1.PRIOPos;
  652.       *PrioSym = ((MRules)RMRule)->U_1.V_1.PrioSym;
  653.       *PrioSymPos = ((MRules)RMRule)->U_1.V_1.PrioSymPos;
  654.     } else {
  655.       PRIOPos->Line = 0;
  656.       PRIOPos->Column = 0;
  657.       *PrioSym = 0;
  658.       PrioSymPos->Line = 0;
  659.       PrioSymPos->Column = 0;
  660.     }
  661.     *HasPrio = ((MRules)RMRule)->HasPrio;
  662.     RMRule = ((MRules)RMRule)->Next;
  663.     return TRUE;
  664.   }
  665. }
  666.  
  667. BOOLEAN Rules_GetEssentialRule
  668. # ifdef __STDC__
  669. (TokenTab_NonTerminal *Left, Rules_Expression *Right, BOOLEAN *HasPrio)
  670. # else
  671. (Left, Right, HasPrio)
  672. TokenTab_NonTerminal *Left;
  673. Rules_Expression *Right;
  674. BOOLEAN *HasPrio;
  675. # endif
  676. {
  677.   if (!OpenForReading) {
  678.     ERROR((STRING)"GetEssentialRule : You must not read here", 41L);
  679.   }
  680.   if (RMRule == NIL) {
  681.     return FALSE;
  682.   } else {
  683.     *Left = ((MRules)RMRule)->Left;
  684.     *Right = ((MRules)RMRule)->Right;
  685.     *HasPrio = ((MRules)RMRule)->HasPrio;
  686.     RMRule = ((MRules)RMRule)->Next;
  687.     return TRUE;
  688.   }
  689. }
  690.  
  691. void Rules_GetRulesHeader
  692. # ifdef __STDC__
  693. (TokenTab_PosType *RULESPos, Lists_tList *Comment, TokenTab_PosType *CommPos)
  694. # else
  695. (RULESPos, Comment, CommPos)
  696. TokenTab_PosType *RULESPos;
  697. Lists_tList *Comment;
  698. TokenTab_PosType *CommPos;
  699. # endif
  700. {
  701.   *RULESPos = RulesVars.RULESPos;
  702.   *Comment = RulesVars.Comment;
  703.   *CommPos = RulesVars.CommPos;
  704. }
  705.  
  706. static void ERROR
  707. # ifdef __STDC__
  708. (CHAR a[], LONGCARD O_1)
  709. # else
  710. (a, O_1)
  711. CHAR a[];
  712. LONGCARD O_1;
  713. # endif
  714. {
  715.   Strings_tString s;
  716.   OPEN_ARRAY_LOCALS
  717.  
  718.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  719.   COPY_OPEN_ARRAY(a, O_1, CHAR)
  720.   Strings_ArrayToString(a, O_1, &s);
  721.   Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Positions_NoPosition, (LONGCARD)Errors_eString, ADR(s));
  722.   FREE_OPEN_ARRAYS
  723. }
  724.  
  725. void BEGIN_Rules()
  726. {
  727.   static BOOLEAN has_been_called = FALSE;
  728.  
  729.   if (!has_been_called) {
  730.     has_been_called = TRUE;
  731.  
  732.     BEGIN_Lists();
  733.     BEGIN_TokenTab();
  734.     BEGIN_Idents();
  735.     BEGIN_Lists();
  736.     BEGIN_TokenTab();
  737.     BEGIN_Memory();
  738.     BEGIN_Idents();
  739.     BEGIN_Errors();
  740.     BEGIN_Strings();
  741.     BEGIN_Positions();
  742.  
  743.     RMRule = (Rules_MRules)NIL;
  744.     WMRule = (Rules_MRules)NIL;
  745.     StartMRule = (Rules_MRules)NIL;
  746.     RulesVars.RULESPos.Line = 0;
  747.     RulesVars.RULESPos.Column = 0;
  748.     Lists_MakeList(&RulesVars.Comment);
  749.     RulesVars.CommPos.Line = 0;
  750.     RulesVars.CommPos.Column = 0;
  751.     Rules_NoExpression = (Rules_Expression)NIL;
  752.   }
  753. }
  754.